import time
import configs
from configs import languages
import speech_parsing
from utils import service_functions
from write_stream import Class_control_messages
from speech_parsing import *
from template.singleton import Singleton
from .call_funcs import Calls_funcs
from core_thread import events
from ..work_mode import Work_mode


class Wrapper_calls_func(Calls_funcs, Singleton):
    def __init__(self) -> None:
        super().__init__()

    def check_event_mess(self):
        for mess in events.event_mess(self.obj_control_mess):
            if mess != None:
                if self.activation_mess({}):
                    self.obj_control_mess.message(mess)
                else:
                    pass

    def init_calls_events(self):
        self.set_work_mode(self.obj_work_mode)
        self.obj_work_mode.add_func(
            self.obj_settings.activ_name,
            {"old_time_update": time.time(), "timing": configs.value_timer_sleep},
        )
        return self.obj_work_mode

    def Main_call_func(self):
        # Функция вызова помощника по имени
        # Проверка на имя помощника

        # self.check_event_mess()

        cmd_say = self.obj_wrap_decoder.name_activation()
        # print(cmd_say,2222222)
        # Если вызвали его
        # if len(name_or_func) != 0 and
        if cmd_say:
            # print(cmd_say,3333333)
            # ТО ищем функции
            # print(cmd_say, 111111)
            funcs = self.obj_wrap_decoder.activation_func(cmd_say)
            self.calls_cmd_no_spech_recogn(funcs, cmd_say)

    def calls_cmd_no_spech_recogn(self, funcs: list, cmd_say="") -> None:
        for func in funcs:
            cheek_say_value = self.obj_wrap_decoder.cheek_say(
                configs.cmds_void[func]["word_list"][0]
            )
            if cheek_say_value:
                label = self.label_approval(func)
                if label:
                    self.call_function(func)
                elif not label:
                    tags = ""
                    tags_v2 = self.obj_tags_v2.cheek_tags_v2(func, cmd_say)
                    if tags_v2 == "tags":
                        tags = self.obj_tags_wrap.selection_tags(tags, func)
                        if self.obj_tags_wrap.cheek_key_or_tag(func, tags) and tags:
                            # print(value_tags,"[vzxm omadfkpv'm pdv0000000000001111")
                            self.call_function(func, tags)
                        else:
                            # print(configs.languages)
                            self.obj_control_mess.message(
                                configs.languages["call_funcs=>Wrapper_calls_func"][
                                    "calls_FALSE_TAGS"
                                ]
                            )
                    elif tags_v2 == "key":
                        value_tags = self.obj_tags_v2.dict_word_searhc(cmd_say, func)
                        # print(value_tags,"[vzxm omadfkpv'm pdv00000000000022222")
                        if (
                            value_tags
                            and value_tags["key_value"]
                            and value_tags["values"]
                        ):
                            self.call_function(func, value_tags)
                        else:
                            self.obj_control_mess.message("Список ключевых слов пуст")
                        # else:
                        # self.obj_control_mess.message(languages["call_funcs=>Wrapper_calls_func"]["calls_FALSE_TAGS"])
                    else:
                        pass
                else:
                    self.obj_control_mess.message(
                        configs.languages["call_funcs=>Wrapper_calls_func"][
                            "calls_cmd_no_spech_recogn"
                        ]
                    )
            else:
                self.obj_control_mess.message(
                    configs.languages["call_funcs=>Wrapper_calls_func"][
                        "calls_NOT_UNDERSTAND"
                    ]
                )

    def call_loop_func(self, funcs=""):
        # Функция нужна для того ,чтобы одной функции можно было каждый раз
        # задавать параметры
        menu_flag = ""
        if not funcs:
            self.obj_control_mess.message("Циклическая вызов функций. Скажите функцию")
            funcs = self.obj_wrap_decoder.activation_func(
                service_functions.queue_voice_str_api()
            )
        while "end" not in menu_flag:
            # Сделать время ожидания функции
            str_cmd = service_functions.queue_voice_time_str_api()
            cmd = self.obj_wrap_decoder.function_recognition(str_cmd, "loop_make")
            if cmd:
                cmd = cmd[0]
                if cmd in configs.cmds["loop_make"]:
                    menu_flag = cmd
                if ("pause" not in menu_flag) and ("return_tags" not in menu_flag):
                    if funcs:
                        self.calls_cmd_no_spech_recogn(funcs)
                    else:
                        return "Функция не обнаружена"
                elif "return_tags" in menu_flag:
                    for index, func in enumerate(funcs):
                        self.obj_control_mess.message(
                            f'Будет вызвана функция "{configs.cmds_void[func]["word_list"][0]}"'
                        )
                elif "clear" in menu_flag:
                    str_cmd = service_functions.queue_voice_time_str_api()
                    funcs = self.obj_wrap_decoder.activation_func(str_cmd)
                    if len(funcs) == 1:
                        self.obj_control_mess.message("Заданна новая функция")
                    elif len(funcs) > 1:
                        self.obj_control_mess.message("Заданны новые функции")
                    elif not funcs:
                        self.obj_control_mess.message("Список функций пуст")
                    else:
                        menu_flag = "end"
                else:
                    pass
        return "Завершение обработки функций"

    # !!!
    def loop_func(self, func: str, time_aut=1, kol: int = 3, tags=[]) -> None:
        if len(tags) == 0:
            for x in range(0, kol):
                # Вызов функции
                time.sleep(time_aut)
                self.call_function(func)
        else:
            for x in range(0, kol):
                # Вызов функции
                time.sleep(time_aut)
                self.call_function(func, tags)


# метка 255 метка 255 метка 255
# экспериментальные функции ядра
